Observer Pattern

Observer Pattern က Mobile App Development တွေ လုပ်သည့် အခါမှာ မဖြစ်မနေသုံးနေကြ pattern တစ်ခုပါ။ MVVM (Model View View Model) ကို သုံးသည့် အခါမှာ observer pattern ကို အသုံးပြုပြီး ရေးကြတာတွေ ရှိပါတယ်။ Button က increase ကို နှိပ်လိုက်ရင် listen လုပ်ထားသည့် function က အလုပ်လုပ်ပြီး label ကို update လုပ်လိုက် သလိုမျိုးပေါ့။

Observer Pattern က Behavioral Patterns တစ်ခု ဖြစ်ပါတယ်။ အဓိက အပိုင်းကတော့ publisher နဲ့ subscriber ရှိတာပါပဲ။ Web Development ပိုင်းမှာ ဆိုရင် web socket က observer pattern ကို သုံးထားပါတယ်။​ Publisher တစ်ခု ကနေ multiple subscriber ဆီ ကို notify လုပ်လို့ရပါတယ်။ Publish Subscribe pattern လို့လည်း ခေါ်ကြပါတယ်။

Observer Pattern မှာ Subject နဲ့ Observers ပါပါတယ်။

• Subject (Observable) ဆိုတာ က တော့ Observer Objects တွေကို သိမ်းထားပြီး changes ဖြစ်တိုင်း အဲဒီ object တွေကို notification ပို့ပေးတာပါ။ သူ့မှာ object ကို register လုပ်ဖို့ unregister လုပ်ဖို့ တွေ ရှိပါတယ်
• Observers ဆိုတာ က  Subject က ပို့လိုက်သည့် notification ကို handle လုပ်ဖို့ အတွက်ပါ။ သူက interface ပါ။
• ConcreteObserver ဆိုတာ က တော့ Observers ရဲ့ interface ကို implement လုပ်ပြီး တကယ့် အလုပ်တွေ လုပ်မည့် class ပါ။

UML class diagram ကို ကြည့်ရအောင်။

အခု Event နဲ့ Event Source ပဲ ရှိသည့် sample code ကို ကြည့်ရအောင်။

UML Diagram ကို မြင်သည့် အခါမှာ code ကို မြင်နိုင်ပါလိမ့်မယ်။ Java code အနေနဲ့ ကြည့်ကြည့်ရအောင်။

public interface Observer {
    void update(String event);
}

public class Event implements Observer {
    @Override
    public void update(String event) {
        // Implement the update method
    }
}

public class EventSource {
    private List<Observer> observers;

    public void notifyObservers(String event) {
        for (Observer observer : observers) {
            observer.update(event);
        }
    }

    public void addObserver(Observer observer) {
        observers.add(observer);
    }
}

public class ObserverDemo {
    public static void main(String[] args) {
        
        EventSource eventSource = new EventSource();
        
        Event event1 = new Event();
        Event event2 = new Event();
        eventSource.addObserver(event1);
        eventSource.addObserver(event2);

        eventSource.notifyObservers("Event occurred");
    }
}

Code ရဲ့ Sequence Diagram ကို ကြည့်ရအောင်။

ဒီ code သဘောတရားကို သဘောပေါက်ပြီ ဆိုရင် Scoreboard App ကို စဥ်းစားကြည့်ရအောင်။

public class Scoreboard {

    private int score;
    private List<Observer> observers = new ArrayList<>();

    public void setScore(int newScore) {
        score = newScore;
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void unregisterObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(score);
        }
    }
}

public interface Observer {
    void update(int score);
}

public class PlayerScoreDisplay implements Observer {

    private Scoreboard scoreboard;

    @Override
    public void update(int score) {
        System.out.println("Player score: " + score);
    }
}

Observer Pattern က Listener တစ်ခု ထက် မက ရှိသည့် ကိစ္စတွေမှာ အဆင်ပြေပါတယ်။​ ဥပမာ Score Board App မှာ Score Board ကို ပွဲရဲ့ နေရာ ၂ ခု မှာ ပြပေးမယ် , နောက်ပြီး Online အတွက်လည်း data ပို့ပေးရမယ် ဆိုရင် notify လုပ်လိုက်ရုံနဲ့ အကုန်လုံးမှာ update ဖြစ်သွားမှာ ဖြစ်ပါတယ်။

နောက်ပြီး Stock Value changes ဖြစ်တိုင်း notify လုပ်မယ့် program တွေကို observer pattern ကို အသုံးပြုပြီး ရေးသားနိုင်ပါတယ်။

Pros and Cons

Open/Closed Principle ကို follow လုပ်ထားပါတယ်။ Subscriber အသစ်ကို publisher က code မပြောင်းလဲပဲ update နိုင်ပါတယ်။

မကောင်းတာကတော့ subscriber က random order နဲ့ လာကောင်းလာနိုင်တယ်။ ဘယ် အဆင့်ပြီးမှ ဒီ function ရောက်ဆိုတာ မရှိပဲ notify လုပ်လိုက်တာနဲ့ subscriber ထဲကို ရောက်လာမှာပါ။